//: [Previous](@previous)

/*:
 * 函数是一段完成特定任务的独立代码片段。你可以通过给函数命名来标识某个函数的功能，这个名字可以被用来在需要的时候“调用”这个函数来完成它的任务。
 
 * 参数可以提供默认值，以简化函数调用。
 
 * 参数也可以既当做传入参数，也当做传出参数，也就是说，一旦函数执行结束，传入的参数值将被修改。
 
 * 在 Swift 中，每个函数都有一个由函数的参数值类型和返回值类型组成的类型。
 
 * 你可以把函数类型当做任何其他普通变量类型一样处理，这样就可以更简单地把函数当做别的函数的参数，也可以从其他函数中返回函数。
 
 * 函数的定义可以写在其他函数定义中，这样可以在嵌套函数范围内实现功能封装。
 */

/*:
 #### 多重返回值函数
 
 * 你可以用元组（tuple）类型让多个值作为一个复合值从函数中返回。
 
 * 需要注意的是，元组的成员不需要在元组从函数中返回时命名，因为它们的名字已经在函数返回类型中指定了。
 
 * 如果函数返回的元组类型有可能整个元组都“没有值”，你可以使用可选的 元组返回类型反映整个元组可以是 nil 的事实。你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组，例如 (Int, Int)? 或 (String, Int, Bool)?
 
 * 可选元组类型如 (Int, Int)? 与元组包含可选类型如 (Int?, Int?) 是不同的。可选的元组类型，整个元组是可选的，而不只是元组中的每个元素值。
 */

import Foundation

func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty { return nil }
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}
if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
    print("min is \(bounds.min) and max is \(bounds.max)")
}
// 打印“min is -6 and max is 109”

/*:
 #### 隐式返回的函数
 如果一个函数的整个函数体是一个单行表达式，这个函数可以隐式地返回这个表达式。也就是忽略return
 */

func greeting(for person: String) -> String {
    "Hello, " + person + "!" // 这里可以忽略return
}
print(greeting(for: "Dave"))
// 打印 "Hello, Dave!"

func anotherGreeting(for person: String) -> String {
    return "Hello, " + person + "!"
}
print(anotherGreeting(for: "Dave"))
// 打印 "Hello, Dave!"

/*:
 #### 函数参数标签和参数名称
 
 * 每个函数参数都有一个参数标签（argument label）以及一个参数名称（parameter name）。
 
 * 参数标签在调用函数的时候使用；调用的时候需要将函数的参数标签写在对应的参数前面。
 
 * 参数名称在函数的实现中使用。
 
 * 你可以在参数名称前指定它的参数标签，中间以空格分隔。参数标签可以不写。默认情况下，函数参数使用参数名称来作为它们的参数标签。（参数标签和参数名称可以用同一个）
 
 * 如果你不希望为某个参数添加一个标签，可以使用一个下划线（_）来代替一个明确的参数标签。（这是去掉参数标签）
 ```
 func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
      // 在函数体内，firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
 }
 someFunction(1, secondParameterName: 2)
 ```
 
 #### 默认参数值
 你可以在函数体中通过给参数赋值来为任意一个参数定义默认值（Deafult Value）。当默认值被定义后，调用这个函数时可以忽略这个参数。
 
 ```
 func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
     // 如果你在调用时候不传第二个参数，parameterWithDefault 会值为 12 传入到函数体中。
 }
 someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault = 6
 someFunction(parameterWithoutDefault: 4) // parameterWithDefault = 12
 ```
 */

/*:
 #### 可变参数
 
 * 一个可变参数（variadic parameter）可以接受零个或多个值。
 
 * 函数调用时，你可以用可变参数来指定函数参数可以被传入不确定数量的输入值。
 
 * 通过在变量类型名后面加入（...）的方式来定义可变参数。
 
 * 可变参数的传入值在函数体中变为此类型的一个数组。例如，一个叫做 numbers 的 Double... 型可变参数，在函数体内可以当做一个叫 numbers 的 [Double] 型的数组常量。
 
 * 一个函数能拥有多个可变参数。可变参数后的第一个行参前必须加上实参标签。实参标签用于区分实参是传递给可变参数，还是后面的行参。
 
 */

func arithmeticMean(_ numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// 返回 3.0, 是这 5 个数的平均数。
arithmeticMean(3, 8.25, 18.75)
// 返回 10.0, 是这 3 个数的平均数。

/*:
 #### 输入输出参数
 
 * 函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。这意味着你不能错误地更改参数值。
 
 * 如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）。
 
 * 定义一个输入输出参数时，在参数定义前加 inout 关键字。一个 输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。
 
 * 你只能传递变量给输入输出参数。你不能传入常量或者字面量，因为这些量是不能被修改的。
 
 * 当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改。
 
 * 输入输出参数不能有默认值，而且可变参数不能用 inout 标记。
 
 * 输入输出参数和返回值是不一样的。上面的 swapTwoInts 函数并没有定义任何返回值，但仍然修改了 someInt 和 anotherInt 的值。输入输出参数是函数对函数体外产生影响的另一种方式。
 
 */

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
// 打印“someInt is now 107, and anotherInt is now 3”

/*:
 #### 函数类型
 
 * 每个函数都有种特定的函数类型，函数的类型由函数的参数类型和返回类型组成。
 
 * 使用函数类型就像使用其他类型一样。
 
 * 你可以用 (Int, Int) -> Int 这样的函数类型作为另一个函数的参数类型。
 
 * 你可以用函数类型作为另一个函数的返回类型。你需要做的是在返回箭头（->）后写一个完整的函数类型。
 
 */

func addTwoInts(_ a: Int, _ b: Int) -> Int {
    return a + b
}
func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
    return a * b
}

var mathFunction: (Int, Int) -> Int = addTwoInts
print("Result: \(mathFunction(2, 3))")
// Prints "Result: 5"
mathFunction = multiplyTwoInts
print("Result: \(mathFunction(2, 3))")
// Prints "Result: 6"
func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    print("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// 打印“Result: 8”

// 归零
func stepForward(_ input: Int) -> Int {
    return input + 1
}
func stepBackward(_ input: Int) -> Int {
    return input - 1
}
func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    return backward ? stepBackward : stepForward
}

var currentValue = 3
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
// moveNearerToZero 现在指向 stepBackward() 函数。
print("Counting to zero:")
// Counting to zero:
while currentValue != 0 {
    print("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// 3...
// 2...
// 1...
// zero!

/*:
 #### 嵌套函数
 
 * 你也可以把函数定义在别的函数体中，称作 嵌套函数（nested functions）。

 * 默认情况下，嵌套函数是对外界不可见的，但是可以被它们的外围函数（enclosing function）调用。一个外围函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。
 */

//: [Next](@next)
